home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr47 / 335_03.zip / ASZ8.Y < prev    next >
Text File  |  1993-04-01  |  38KB  |  1,684 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     asz8.y;
  13. WARNINGS:     "This software is in the public domain.  
  14.         Any prior copyright claims are relinquished.  
  15.  
  16.         This software is distributed with no warranty whatever.  
  17.         The author takes no responsibility for the consequences 
  18.         of its use.
  19.  
  20.         Yacc (or Bison) required to compile."  ;
  21. SEE-ALSO:     asz8.doc,frasmain.c;    
  22. AUTHORS:     Mark Zenier;
  23. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  24.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  25. */
  26. /* z8 instruction generation file */
  27. /* November 17, 1990 */
  28.  
  29. /*
  30.     description    frame work parser description for framework cross
  31.             assemblers
  32.     history        February 2, 1988
  33.             September 11, 1990 - merge table definition
  34.             September 12, 1990 - short file names
  35.             September 14, 1990 - short variable names
  36.             September 17, 1990 - use yylex as external
  37. */
  38. #include <stdio.h>
  39. #include "frasmdat.h"
  40. #include "fragcon.h"
  41.  
  42. #define yylex lexintercept
  43.  
  44. /*
  45.     file        critz8.h
  46.     author        Mark Zenier
  47.     description    Selection criteria and syntax type constants for
  48.             the z8 framework assembler
  49.     usage        Unix
  50.     history        October 28, 1987
  51. */
  52.  
  53. /* 0000.0000.0000.000x   destination register is in working set */
  54. #define    DSTWORK    0x1
  55.  
  56. /* 0000.0000.0000.00x0    destination is double register */
  57. #define DSTDBL    0x2
  58.  
  59. /* 0000.0000.0000.0x00   source register is in working set */
  60. #define SRCWORK    0x4
  61.  
  62. /* 0000.0000.0000.x000    source is double register */
  63. #define SRCDBL    0x8
  64.  
  65. /* type flags for symbol table value for registers */
  66. #define REGFLGSHFT    8
  67. #define REGDFLGSH    REGFLGSHFT
  68. #define REGSFLGSH    (REGFLGSHFT -2)
  69. #define REGFLGS        ((DSTWORK|DSTDBL)<<REGFLGSHFT)
  70. #define REGDEFWRK    (DSTWORK<<REGFLGSHFT)
  71. #define    REGDEFDBL    (DSTDBL<<REGFLGSHFT)
  72. #define REGBITS        0xff
  73. #define REGWORKBITS    0xf
  74.  
  75. #define CPU8600    1    /* use z8 register set */
  76. #define CPU8090    2    /* use UPC register set */
  77. #define ST_CEXP 0x1
  78. #define ST_EXP 0x2
  79. #define ST_INH 0x4
  80. #define ST_IR1 0x8
  81. #define ST_IRIM 0x10
  82. #define ST_IRIR 0x20
  83. #define ST_IRR 0x40
  84. #define ST_R1 0x80
  85. #define ST_R2 0x100
  86. #define ST_REXP 0x200
  87. #define ST_RIMM 0x400
  88. #define ST_RIR 0x800
  89. #define ST_RX 0x1000
  90. #define ST_XR 0x2000
  91. #define ST_IMM 0x1
  92.     
  93.     int cpuselect = CPU8600;
  94.     static char    genbdef[] = "[1=];";
  95.     static char    genwdef[] = "[1=]x";
  96.     char ignosyn[] = "[Xinvalid syntax for instruction";
  97.     char ignosel[] = "[Xinvalid operands";
  98.     int    prevregwork = 0;
  99.     int    regloccnt = 0;
  100.  
  101.     long    labelloc;
  102.     static int satsub;
  103.     int    ifstkpt = 0;
  104.     int    fraifskip = FALSE;
  105.  
  106.     struct symel * endsymbol = SYMNULL;
  107.  
  108. %}
  109. %union {
  110.     int    intv;
  111.     long     longv;
  112.     char    *strng;
  113.     struct symel *symb;
  114. }
  115.  
  116. %token <intv> REGISTER
  117. %token <intv> CONDITION
  118.  
  119. %type <intv> regdefop regoperand
  120.  
  121. %token <intv> KOC_BDEF
  122. %token <intv> KOC_ELSE
  123. %token <intv> KOC_END
  124. %token <intv> KOC_ENDI
  125. %token <intv> KOC_EQU
  126. %token <intv> KOC_IF
  127. %token <intv> KOC_INCLUDE
  128. %token <intv> KOC_ORG
  129. %token <intv> KOC_RESM
  130. %token <intv> KOC_SDEF
  131. %token <intv> KOC_SET
  132. %token <intv> KOC_WDEF
  133. %token <intv> KOC_CHSET
  134. %token <intv> KOC_CHDEF
  135. %token <intv> KOC_CHUSE
  136. %token <intv> KOC_REG
  137. %token <intv> KOC_RREG
  138. %token <intv> KOC_CPU
  139. %token <intv> KOC_opcode
  140. %token <intv> KOC_srp
  141.  
  142. %token <longv> CONSTANT
  143. %token EOL
  144. %token KEOP_AND
  145. %token KEOP_DEFINED
  146. %token KEOP_EQ
  147. %token KEOP_GE
  148. %token KEOP_GT
  149. %token KEOP_HIGH
  150. %token KEOP_LE
  151. %token KEOP_LOW
  152. %token KEOP_LT
  153. %token KEOP_MOD
  154. %token KEOP_MUN
  155. %token KEOP_NE
  156. %token KEOP_NOT
  157. %token KEOP_OR
  158. %token KEOP_SHL
  159. %token KEOP_SHR
  160. %token KEOP_XOR
  161. %token KEOP_locctr
  162. %token <symb> LABEL
  163. %token <strng> STRING
  164. %token <symb> SYMBOL
  165.  
  166. %token KTK_invalid
  167.  
  168. %right    KEOP_HIGH KEOP_LOW
  169. %left    KEOP_OR KEOP_XOR
  170. %left    KEOP_AND
  171. %right    KEOP_NOT
  172. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  173. %left    '+' '-'
  174. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  175. %right    KEOP_MUN
  176.  
  177.  
  178. %type <intv> expr exprlist stringlist
  179.  
  180. %start file
  181.  
  182. %%
  183.  
  184. file    :    file allline
  185.     |    allline
  186.     ;
  187.  
  188. allline    :     line EOL
  189.             {
  190.                 clrexpr();
  191.             }
  192.     |    EOL
  193.     |    error EOL
  194.             {
  195.                 clrexpr();
  196.                 yyerrok;
  197.             }
  198.     ;
  199.  
  200. line    :    LABEL KOC_END 
  201.             {
  202.                 endsymbol = $1;
  203.                 nextreadact = Nra_end;
  204.             }
  205.     |          KOC_END 
  206.             {
  207.                 nextreadact = Nra_end;
  208.             }
  209.     |    KOC_INCLUDE STRING
  210.             {
  211.         if(nextfstk >= FILESTKDPTH)
  212.         {
  213.             fraerror("include file nesting limit exceeded");
  214.         }
  215.         else
  216.         {
  217.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  218.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  219.                 ==(FILE *)NULL )
  220.             {
  221.                 fraerror("cannot open include file");
  222.             }
  223.             else
  224.             {
  225.                 nextreadact = Nra_new;
  226.             }
  227.         }
  228.             }
  229.     |    LABEL KOC_EQU expr 
  230.             {
  231.                 if($1 -> seg == SSG_UNDEF)
  232.                 {
  233.                     pevalexpr(0, $3);
  234.                     if(evalr[0].seg == SSG_ABS)
  235.                     {
  236.                         $1 -> seg = SSG_EQU;
  237.                         $1 -> value = evalr[0].value;
  238.                         prtequvalue("C: 0x%lx\n",
  239.                             evalr[0].value);
  240.                     }
  241.                     else
  242.                     {
  243.                         fraerror(
  244.                     "noncomputable expression for EQU");
  245.                     }
  246.                 }
  247.                 else
  248.                 {
  249.                     fraerror(
  250.                 "cannot change symbol value with EQU");
  251.                 }
  252.             }
  253.     |    LABEL KOC_SET expr 
  254.             {
  255.                 if($1 -> seg == SSG_UNDEF
  256.                    || $1 -> seg == SSG_SET)
  257.                 {
  258.                     pevalexpr(0, $3);
  259.                     if(evalr[0].seg == SSG_ABS)
  260.                     {
  261.                         $1 -> seg = SSG_SET;
  262.                         $1 -> value = evalr[0].value;
  263.                         prtequvalue("C: 0x%lx\n",
  264.                             evalr[0].value);
  265.                     }
  266.                     else
  267.                     {
  268.                         fraerror(
  269.                     "noncomputable expression for SET");
  270.                     }
  271.                 }
  272.                 else
  273.                 {
  274.                     fraerror(
  275.                 "cannot change symbol value with SET");
  276.                 }
  277.             }
  278.     |    KOC_IF expr 
  279.             {
  280.         if((++ifstkpt) < IFSTKDEPTH)
  281.         {
  282.             pevalexpr(0, $2);
  283.             if(evalr[0].seg == SSG_ABS)
  284.             {
  285.                 if(evalr[0].value != 0)
  286.                 {
  287.                     elseifstk[ifstkpt] = If_Skip;
  288.                     endifstk[ifstkpt] = If_Active;
  289.                 }
  290.                 else
  291.                 {
  292.                     fraifskip = TRUE;
  293.                     elseifstk[ifstkpt] = If_Active;
  294.                     endifstk[ifstkpt] = If_Active;
  295.                 }
  296.             }
  297.             else
  298.             {
  299.                 fraifskip = TRUE;
  300.                 elseifstk[ifstkpt] = If_Active;
  301.                 endifstk[ifstkpt] = If_Active;
  302.             }
  303.         }
  304.         else
  305.         {
  306.             fraerror("IF stack overflow");
  307.         }
  308.             }
  309.                         
  310.     |    KOC_IF 
  311.             {
  312.         if(fraifskip) 
  313.         {
  314.             if((++ifstkpt) < IFSTKDEPTH)
  315.             {
  316.                     elseifstk[ifstkpt] = If_Skip;
  317.                     endifstk[ifstkpt] = If_Skip;
  318.             }
  319.             else
  320.             {
  321.                 fraerror("IF stack overflow");
  322.             }
  323.         }
  324.         else
  325.         {
  326.             yyerror("syntax error");
  327.             YYERROR;
  328.         }
  329.                 }
  330.                         
  331.     |    KOC_ELSE 
  332.             {
  333.                 switch(elseifstk[ifstkpt])
  334.                 {
  335.                 case If_Active:
  336.                     fraifskip = FALSE;
  337.                     break;
  338.                 
  339.                 case If_Skip:
  340.                     fraifskip = TRUE;
  341.                     break;
  342.                 
  343.                 case If_Err:
  344.                     fraerror("ELSE with no matching if");
  345.                     break;
  346.                 }
  347.             }
  348.  
  349.     |    KOC_ENDI 
  350.             {
  351.                 switch(endifstk[ifstkpt])
  352.                 {
  353.                 case If_Active:
  354.                     fraifskip = FALSE;
  355.                     ifstkpt--;
  356.                     break;
  357.                 
  358.                 case If_Skip:
  359.                     fraifskip = TRUE;
  360.                     ifstkpt--;
  361.                     break;
  362.                 
  363.                 case If_Err:
  364.                     fraerror("ENDI with no matching if");
  365.                     break;
  366.                 }
  367.             }
  368.     |    LABEL KOC_ORG expr 
  369.             {
  370.                 pevalexpr(0, $3);
  371.                 if(evalr[0].seg == SSG_ABS)
  372.                 {
  373.                     locctr = labelloc = evalr[0].value;
  374.                     if($1 -> seg == SSG_UNDEF)
  375.                     {
  376.                         $1 -> seg = SSG_ABS;
  377.                         $1 -> value = labelloc;
  378.                     }
  379.                     else
  380.                         fraerror(
  381.                         "multiple definition of label");
  382.                     prtequvalue("C: 0x%lx\n",
  383.                         evalr[0].value);
  384.                 }
  385.                 else
  386.                 {
  387.                     fraerror(
  388.                      "noncomputable expression for ORG");
  389.                 }
  390.             }
  391.     |          KOC_ORG expr 
  392.             {
  393.                 pevalexpr(0, $2);
  394.                 if(evalr[0].seg == SSG_ABS)
  395.                 {
  396.                     locctr = labelloc = evalr[0].value;
  397.                     prtequvalue("C: 0x%lx\n",
  398.                         evalr[0].value);
  399.                 }
  400.                 else
  401.                 {
  402.                     fraerror(
  403.                      "noncomputable expression for ORG");
  404.                 }
  405.             }
  406.     |    LABEL KOC_CHSET
  407.             {
  408.                 if($1 -> seg == SSG_UNDEF)
  409.                 {
  410.                     $1 -> seg = SSG_EQU;
  411.                     if( ($1->value = chtcreate()) <= 0)
  412.                     {
  413.         fraerror( "cannot create character translation table");
  414.                     }
  415.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  416.                 }
  417.                 else
  418.                 {
  419.             fraerror( "multiple definition of label");
  420.                 }
  421.             }
  422.     |        KOC_CHUSE
  423.             {
  424.                 chtcpoint = (int *) NULL;
  425.                 prtequvalue("C: 0x%lx\n", 0L);
  426.             }
  427.     |        KOC_CHUSE expr
  428.             {
  429.                 pevalexpr(0, $2);
  430.                 if( evalr[0].seg == SSG_ABS)
  431.                 {
  432.                     if( evalr[0].value == 0)
  433.                     {
  434.                         chtcpoint = (int *)NULL;
  435.                         prtequvalue("C: 0x%lx\n", 0L);
  436.                     }
  437.                     else if(evalr[0].value < chtnxalph)
  438.                     {
  439.                 chtcpoint = chtatab[evalr[0].value];
  440.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  441.                     }
  442.                     else
  443.                     {
  444.             fraerror("nonexistent character translation table");
  445.                     }
  446.                 }
  447.                 else
  448.                 {
  449.                     fraerror("noncomputable expression");
  450.                 }
  451.             }
  452.     |        KOC_CHDEF STRING ',' exprlist
  453.             {
  454.         int findrv, numret, *charaddr;
  455.         char *sourcestr = $2, *before;
  456.  
  457.         if(chtnpoint != (int *)NULL)
  458.         {
  459.             for(satsub = 0; satsub < $4; satsub++)
  460.             {
  461.                 before = sourcestr;
  462.  
  463.                 pevalexpr(0, exprlist[satsub]);
  464.                 findrv = chtcfind(chtnpoint, &sourcestr,
  465.                         &charaddr, &numret);
  466.                 if(findrv == CF_END)
  467.                 {
  468.             fraerror("more expressions than characters");
  469.                     break;
  470.                 }
  471.  
  472.                 if(evalr[0].seg == SSG_ABS)
  473.                 {
  474.                     switch(findrv)
  475.                     {
  476.                     case CF_UNDEF:
  477.                         {
  478.                 if(evalr[0].value < 0 ||
  479.                     evalr[0].value > 255)
  480.                 {
  481.             frawarn("character translation value truncated");
  482.                 }
  483.                 *charaddr = evalr[0].value & 0xff;
  484.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  485.                         }
  486.                         break;
  487.  
  488.                     case CF_INVALID:
  489.                     case CF_NUMBER:
  490.                 fracherror("invalid character to define", 
  491.                     before, sourcestr);
  492.                         break;
  493.  
  494.                     case CF_CHAR:
  495.                 fracherror("character already defined", 
  496.                     before, sourcestr);
  497.                         break;
  498.                     }
  499.                 }
  500.                 else
  501.                 {
  502.                     fraerror("noncomputable expression");
  503.                 }
  504.             }
  505.  
  506.             if( *sourcestr != '\0')
  507.             {
  508.                 fraerror("more characters than expressions");
  509.             }
  510.         }
  511.         else
  512.         {
  513.             fraerror("no CHARSET statement active");
  514.         }
  515.             
  516.             }
  517.     |    LABEL 
  518.             {
  519.             if($1 -> seg == SSG_UNDEF)
  520.             {
  521.                 $1 -> seg = SSG_ABS;
  522.                 $1 -> value = labelloc;
  523.                 prtequvalue("C: 0x%lx\n", labelloc);
  524.  
  525.             }
  526.             else
  527.                 fraerror(
  528.                 "multiple definition of label");
  529.             }
  530.     |    labeledline
  531.     ;
  532.  
  533. labeledline :    LABEL genline
  534.             {
  535.             if($1 -> seg == SSG_UNDEF)
  536.             {
  537.                 $1 -> seg = SSG_ABS;
  538.                 $1 -> value = labelloc;
  539.             }
  540.             else
  541.                 fraerror(
  542.                 "multiple definition of label");
  543.             labelloc = locctr;
  544.             }
  545.                 
  546.     |    genline
  547.             {
  548.                 labelloc = locctr;
  549.             }
  550.     ;
  551.  
  552. genline    :    KOC_BDEF    exprlist 
  553.             {
  554.                 genlocrec(currseg, labelloc);
  555.                 for( satsub = 0; satsub < $2; satsub++)
  556.                 {
  557.                     pevalexpr(1, exprlist[satsub]);
  558.                     locctr += geninstr(genbdef);
  559.                 }
  560.             }
  561.     |    KOC_SDEF stringlist 
  562.             {
  563.                 genlocrec(currseg, labelloc);
  564.                 for(satsub = 0; satsub < $2; satsub++)
  565.                 {
  566.                     locctr += genstring(stringlist[satsub]);
  567.                 }
  568.             }
  569.     |    KOC_WDEF exprlist 
  570.             {
  571.                 genlocrec(currseg, labelloc);
  572.                 for( satsub = 0; satsub < $2; satsub++)
  573.                 {
  574.                     pevalexpr(1, exprlist[satsub]);
  575.                     locctr += geninstr(genwdef);
  576.                 }
  577.             }    
  578.     |    KOC_RESM expr 
  579.             {
  580.                 pevalexpr(0, $2);
  581.                 if(evalr[0].seg == SSG_ABS)
  582.                 {
  583.                     locctr = labelloc + evalr[0].value;
  584.                     prtequvalue("C: 0x%lx\n", labelloc);
  585.                 }
  586.                 else
  587.                 {
  588.                     fraerror(
  589.                  "noncomputable result for RMB expression");
  590.                 }
  591.             }
  592.     ;
  593.  
  594. exprlist :    exprlist ',' expr
  595.             {
  596.                 exprlist[nextexprs ++ ] = $3;
  597.                 $$ = nextexprs;
  598.             }
  599.     |    expr
  600.             {
  601.                 nextexprs = 0;
  602.                 exprlist[nextexprs ++ ] = $1;
  603.                 $$ = nextexprs;
  604.             }
  605.     ;
  606.  
  607. stringlist :    stringlist ',' STRING
  608.             {
  609.                 stringlist[nextstrs ++ ] = $3;
  610.                 $$ = nextstrs;
  611.             }
  612.     |    STRING
  613.             {
  614.                 nextstrs = 0;
  615.                 stringlist[nextstrs ++ ] = $1;
  616.                 $$ = nextstrs;
  617.             }
  618.     ;
  619.  
  620.  
  621.  
  622. line     :    LABEL regdefop regoperand
  623.             {
  624.         if($1 -> seg == SSG_UNDEF)
  625.         {
  626.             $1 -> value = ( $3 & REGBITS )
  627.                     | ( $3 & REGDEFWRK )
  628.                     | ($2 == 2 ? REGDEFDBL : 0);
  629.             $1 -> seg = SSG_RESV;
  630.             $1 -> tok = REGISTER;
  631.  
  632.             if($3 & REGDEFWRK) 
  633.             {
  634.                 if(($3 & 0xf0) != 0xe0)
  635.                     fraerror(
  636.                 "invalid working register address");
  637.             }
  638.             else
  639.             {
  640.                 switch(cpuselect)
  641.                 {
  642.                 case CPU8600:
  643.                     if( ($3 & REGBITS) > 0x7f &&
  644.                         ($3 & REGBITS) < 0xf0)
  645.                     {
  646.                         fraerror(
  647.                     "unimplemented register address");
  648.                     }
  649.                     break;
  650.  
  651.                 case CPU8090:
  652.                     if( ($3 & REGBITS) > 0xdf &&
  653.                         ($3 & REGBITS) < 0xf0)
  654.                     {
  655.                         fraerror(
  656.                     "unimplemented register address");
  657.                     }
  658.                     break;
  659.  
  660.                 }
  661.             }
  662.  
  663.             if( ( $1 -> value & REGDEFDBL) && ( $1 -> value & 1) )
  664.                 fraerror("double register not on even boundry");
  665.  
  666.             prtequvalue("C: 0x%x\n",REGBITS & ((int) $1->value));
  667.         }
  668.         else
  669.         {
  670.             fraerror("multiple definition of label");
  671.         }
  672.         prevregwork = $3 & REGDEFWRK;
  673.         regloccnt = ($3 & REGBITS) + $2;
  674.             }
  675.     ;
  676.  
  677. regdefop :    KOC_REG
  678.             {
  679.         $$ = 1;
  680.             }
  681.     |    KOC_RREG
  682.             {
  683.         $$ = 2;
  684.             }
  685.     ;
  686.  
  687. regoperand :    REGISTER
  688.             {
  689.         $$ = $1;
  690.             }
  691.     |    expr
  692.             {
  693.         $$ = 0;
  694.         pevalexpr(0, $1);
  695.         if(evalr[0].seg != SSG_ABS)
  696.         {
  697.             fraerror("noncomputable value for REG");
  698.         }
  699.         else
  700.         {
  701.             if(evalr[0].value >= 0 && evalr[0].value <= 255)
  702.                 $$ = evalr[0].value;
  703.             else
  704.                 fraerror("value out of range");
  705.         }
  706.             }
  707.     |
  708.             {
  709.         if(regloccnt <= 255)
  710.             $$ = regloccnt | prevregwork ;
  711.         else
  712.         {
  713.             $$ = 0;
  714.             fraerror("register location counter out of range");
  715.         }
  716.             }
  717.     ;
  718.  
  719. line    :    KOC_CPU STRING
  720.             {
  721.         if( ! cpumatch($2))
  722.         {
  723.             fraerror("unknown cpu type, z8 assumed");
  724.             cpuselect = CPU8600;
  725.         }
  726.             }
  727.     ;
  728. genline : KOC_opcode  CONDITION ',' expr
  729.             {
  730.         genlocrec(currseg, labelloc);
  731.         evalr[1].value = $2;
  732.         pevalexpr(2, $4);
  733.         locctr += geninstr(findgen($1, ST_CEXP, 0));
  734.             }
  735.     ;
  736. genline : KOC_opcode  expr
  737.             {
  738.         genlocrec(currseg, labelloc);
  739.         pevalexpr(1, $2);
  740.         locctr += geninstr(findgen($1, ST_EXP, 0));
  741.             }
  742.     ;
  743. genline : KOC_opcode 
  744.             {
  745.         genlocrec(currseg, labelloc);
  746.         locctr += geninstr(findgen($1, ST_INH, 0));
  747.             }
  748.     ;
  749. genline : KOC_opcode  '@' REGISTER
  750.             {
  751.         genlocrec(currseg, labelloc);
  752.         evalr[1].value = $3 & REGBITS;
  753.         evalr[2].value = $3 & REGWORKBITS;
  754.         locctr += geninstr(findgen($1, ST_IR1, 
  755.             ($3 & REGFLGS) >> REGDFLGSH ));
  756.             }
  757.     ;
  758. genline : KOC_opcode  '@' REGISTER ',' '#' expr
  759.             {
  760.         genlocrec(currseg, labelloc);
  761.         evalr[1].value = $3 & REGBITS;
  762.         evalr[3].value = $3 & REGWORKBITS;
  763.         pevalexpr(2, $6);
  764.         locctr += geninstr(findgen($1, ST_IRIM, 
  765.             ($3 & REGFLGS) >> REGDFLGSH ));
  766.             }
  767.     ;
  768. genline : KOC_opcode  '@' REGISTER ',' '@' REGISTER
  769.             {
  770.         genlocrec(currseg, labelloc);
  771.         evalr[1].value = $3 & REGBITS;
  772.         evalr[2].value = $3 & REGWORKBITS;
  773.         evalr[3].value = $6 & REGBITS;
  774.         evalr[4].value = $6 & REGWORKBITS;
  775.         locctr += geninstr(findgen($1, ST_IRIR, 
  776.             ( ($3 & REGFLGS) >> REGDFLGSH ) |
  777.             ( ($6 & REGFLGS) >> REGSFLGSH ) ));
  778.             }
  779.     ;
  780. genline : KOC_opcode  '@' REGISTER ',' REGISTER
  781.             {
  782.         genlocrec(currseg, labelloc);
  783.         evalr[1].value = $3 & REGBITS;
  784.         evalr[2].value = $3 & REGWORKBITS;
  785.         evalr[3].value = $5 & REGBITS;
  786.         evalr[4].value = $5 & REGWORKBITS;
  787.         locctr += geninstr(findgen($1, ST_IRR, 
  788.             ( ($3 & REGFLGS) >> REGDFLGSH ) |
  789.             ( ($5 & REGFLGS) >> REGSFLGSH ) ));
  790.             }
  791.     ;
  792. genline : KOC_opcode  REGISTER
  793.             {
  794.         genlocrec(currseg, labelloc);
  795.         evalr[1].value = $2 & REGBITS;
  796.         evalr[2].value = $2 & REGWORKBITS;
  797.         locctr += geninstr(findgen($1, ST_R1, 
  798.             ($2 & REGFLGS) >> REGDFLGSH ));
  799.             }
  800.     ;
  801. genline : KOC_opcode  REGISTER ',' REGISTER
  802.             {
  803.         genlocrec(currseg, labelloc);
  804.         evalr[1].value = $2 & REGBITS;
  805.         evalr[2].value = $2 & REGWORKBITS;
  806.         evalr[3].value = $4 & REGBITS;
  807.         evalr[4].value = $4 & REGWORKBITS;
  808.         locctr += geninstr(findgen($1, ST_R2, 
  809.             ( ($2 & REGFLGS) >> REGDFLGSH ) |
  810.             ( ($4 & REGFLGS) >> REGSFLGSH ) ));
  811.             }
  812.     ;
  813. genline : KOC_opcode  REGISTER ',' expr
  814.             {
  815.         genlocrec(currseg, labelloc);
  816.         evalr[1].value = $2 & REGBITS;
  817.         pevalexpr(2, $4);
  818.         evalr[3].value = $2 & REGWORKBITS;
  819.         locctr += geninstr(findgen($1, ST_REXP,
  820.             ($2 & REGFLGS) >> REGDFLGSH ));
  821.             }
  822.     ;
  823. genline : KOC_opcode  REGISTER ',' '#' expr
  824.             {
  825.         genlocrec(currseg, labelloc);
  826.         evalr[1].value = $2 & REGBITS;
  827.         evalr[3].value = $2 & REGWORKBITS;
  828.         pevalexpr(2, $5);
  829.         locctr += geninstr(findgen($1, ST_RIMM, 
  830.             ($2 & REGFLGS) >> REGDFLGSH ));
  831.             }
  832.     ;
  833. genline : KOC_opcode  REGISTER ',' '@' REGISTER
  834.             {
  835.         genlocrec(currseg, labelloc);
  836.         evalr[1].value = $2 & REGBITS;
  837.         evalr[2].value = $2 & REGWORKBITS;
  838.         evalr[3].value = $5 & REGBITS;
  839.         evalr[4].value = $5 & REGWORKBITS;
  840.         locctr += geninstr(findgen($1, ST_RIR, 
  841.             ( ($2 & REGFLGS) >> REGDFLGSH ) |
  842.             ( ($5 & REGFLGS) >> REGSFLGSH ) ));
  843.             }
  844.     ;
  845. genline : KOC_opcode  REGISTER ',' expr '(' REGISTER ')'
  846.             {
  847.         genlocrec(currseg, labelloc);
  848.         evalr[1].value = $2 & REGWORKBITS;
  849.         pevalexpr(2, $4);
  850.         evalr[3].value = $6 & REGWORKBITS;
  851.         locctr += geninstr(findgen($1, ST_RX, 
  852.             ( ($2 & REGFLGS) >> REGDFLGSH ) |
  853.             ( ($6 & REGFLGS) >> REGSFLGSH ) ));
  854.             }
  855.     ;
  856. genline : KOC_opcode  expr '(' REGISTER ')' ',' REGISTER 
  857.             {
  858.         genlocrec(currseg, labelloc);
  859.         pevalexpr(1, $2);
  860.         evalr[2].value = $4 & REGWORKBITS;
  861.         evalr[3].value = $7 & REGWORKBITS;
  862.         locctr += geninstr(findgen($1, ST_XR, 
  863.             ( ($4 & REGFLGS) >> REGDFLGSH ) |
  864.             ( ($7 & REGFLGS) >> REGSFLGSH ) ));
  865.             }
  866.     ;
  867. genline : KOC_srp  '#' expr
  868.             {
  869.         pevalexpr(1, $3);
  870.         if(evalr[1].seg != SSG_ABS)
  871.         {
  872.             fraerror("noncomputable value for SRP");
  873.         }
  874.         else
  875.         {
  876.             switch(( (int) evalr[1].value ) & REGBITS)
  877.             {
  878.             case 0x80:
  879.             case 0x90:
  880.             case 0xa0:
  881.             case 0xb0:
  882.             case 0xc0:
  883.             case 0xd0:
  884.                 if(cpuselect == CPU8600)
  885.                 {
  886.                     fraerror("invalid value for SRP");
  887.                     break;
  888.                 }
  889.                 /* fall thru */
  890.             case 0x00:
  891.             case 0x10:
  892.             case 0x20:
  893.             case 0x30:
  894.             case 0x40:
  895.             case 0x50:
  896.             case 0x60:
  897.             case 0x70:
  898.             case 0xf0:
  899.                 genlocrec(currseg, labelloc);
  900.                 locctr += geninstr(findgen($1, ST_IMM, 0));
  901.                 break;
  902.             default:
  903.                 fraerror("invalid value for SRP");
  904.                 break;
  905.             }
  906.         }
  907.             }
  908.     ;
  909. expr    :    '+' expr %prec KEOP_MUN
  910.             {
  911.                 $$ = $2;
  912.             }
  913.     |    '-' expr %prec KEOP_MUN
  914.             {
  915.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  916.                     SYMNULL);
  917.             }
  918.     |    KEOP_NOT expr
  919.             {
  920.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  921.                     SYMNULL);
  922.             }
  923.     |    KEOP_HIGH expr
  924.             {
  925.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  926.                     SYMNULL);
  927.             }
  928.     |    KEOP_LOW expr
  929.             {
  930.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  931.                     SYMNULL);
  932.             }
  933.     |    expr '*' expr
  934.             {
  935.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  936.                     SYMNULL);
  937.             }
  938.     |    expr '/' expr
  939.             {
  940.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  941.                     SYMNULL);
  942.             }
  943.     |    expr '+' expr
  944.             {
  945.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  946.                     SYMNULL);
  947.             }
  948.     |    expr '-' expr
  949.             {
  950.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  951.                     SYMNULL);
  952.             }
  953.     |    expr KEOP_MOD expr
  954.             {
  955.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  956.                     SYMNULL);
  957.             }
  958.     |    expr KEOP_SHL expr
  959.             {
  960.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  961.                     SYMNULL);
  962.             }
  963.     |    expr KEOP_SHR expr
  964.             {
  965.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  966.                     SYMNULL);
  967.             }
  968.     |    expr KEOP_GT expr
  969.             {
  970.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  971.                     SYMNULL);
  972.             }
  973.     |    expr KEOP_GE expr
  974.             {
  975.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  976.                     SYMNULL);
  977.             }
  978.     |    expr KEOP_LT expr
  979.             {
  980.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  981.                     SYMNULL);
  982.             }
  983.     |    expr KEOP_LE expr
  984.             {
  985.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  986.                     SYMNULL);
  987.             }
  988.     |    expr KEOP_NE expr
  989.             {
  990.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  991.                     SYMNULL);
  992.             }
  993.     |    expr KEOP_EQ expr
  994.             {
  995.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  996.                     SYMNULL);
  997.             }
  998.     |    expr KEOP_AND expr
  999.             {
  1000.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  1001.                     SYMNULL);
  1002.             }
  1003.     |    expr KEOP_OR expr
  1004.             {
  1005.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  1006.                     SYMNULL);
  1007.             }
  1008.     |    expr KEOP_XOR expr
  1009.             {
  1010.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  1011.                     SYMNULL);
  1012.             }
  1013.     |    KEOP_DEFINED SYMBOL
  1014.             {
  1015.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  1016.             }
  1017.     |    SYMBOL
  1018.             {
  1019.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  1020.             }
  1021.     |    '*'
  1022.             {
  1023.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  1024.                     labelloc, SYMNULL);
  1025.             }
  1026.     |    CONSTANT
  1027.             {
  1028.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  1029.                     SYMNULL);
  1030.             }
  1031.     |    STRING
  1032.             {
  1033.                 char *sourcestr = $1;
  1034.                 long accval = 0;
  1035.  
  1036.                 if(strlen($1) > 0)
  1037.                 {
  1038.                     accval = chtran(&sourcestr);
  1039.                     if(*sourcestr != '\0')
  1040.                     {
  1041.                         accval = (accval << 8) +
  1042.                             chtran(&sourcestr);
  1043.                     }
  1044.  
  1045.                     if( *sourcestr != '\0')
  1046.                     {
  1047.     frawarn("string constant in expression more than 2 characters long");
  1048.                     }
  1049.                 }
  1050.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  1051.                     accval, SYMNULL);
  1052.             }
  1053.     |    '(' expr ')'
  1054.             {
  1055.                 $$ = $2;
  1056.             }
  1057.     ;
  1058.  
  1059. expr    :    '(' REGISTER ')'
  1060.         {
  1061.     $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,
  1062.         (long) (REGBITS & $2),
  1063.         SYMNULL);
  1064.         }
  1065.     ;
  1066.  
  1067. %%
  1068.  
  1069. lexintercept()
  1070. /*
  1071.     description    intercept the call to yylex (the lexical analyzer)
  1072.             and filter out all unnecessary tokens when skipping
  1073.             the input between a failed IF and its matching ENDI or
  1074.             ELSE
  1075.     globals     fraifskip    the enable flag
  1076. */
  1077. {
  1078. #undef yylex
  1079.  
  1080.     int rv;
  1081.  
  1082.     if(fraifskip)
  1083.     {
  1084.         for(;;)
  1085.         {
  1086.  
  1087.             switch(rv = yylex())
  1088.  
  1089.             {
  1090.             case 0:
  1091.             case KOC_END:
  1092.             case KOC_IF:
  1093.             case KOC_ELSE:
  1094.             case KOC_ENDI:
  1095.             case EOL:
  1096.                 return rv;
  1097.             default:
  1098.                 break;
  1099.             }
  1100.         }
  1101.     }
  1102.     else
  1103.         return yylex();
  1104. #define yylex lexintercept
  1105. }
  1106.  
  1107.  
  1108.  
  1109. setreserved()
  1110. {
  1111.  
  1112.     reservedsym("and", KEOP_AND, 0);
  1113.     reservedsym("defined", KEOP_DEFINED,0);
  1114.     reservedsym("high", KEOP_HIGH, 0);
  1115.     reservedsym("low", KEOP_LOW, 0);
  1116.     reservedsym("mod", KEOP_MOD, 0);
  1117.     reservedsym("not", KEOP_NOT, 0);
  1118.     reservedsym("or", KEOP_OR, 0);
  1119.     reservedsym("shl", KEOP_SHL, 0);
  1120.     reservedsym("shr", KEOP_SHR, 0);
  1121.     reservedsym("xor", KEOP_XOR, 0);
  1122.     reservedsym("AND", KEOP_AND, 0);
  1123.     reservedsym("DEFINED", KEOP_DEFINED,0);
  1124.     reservedsym("HIGH", KEOP_HIGH, 0);
  1125.     reservedsym("LOW", KEOP_LOW, 0);
  1126.     reservedsym("MOD", KEOP_MOD, 0);
  1127.     reservedsym("NOT", KEOP_NOT, 0);
  1128.     reservedsym("OR", KEOP_OR, 0);
  1129.     reservedsym("SHL", KEOP_SHL, 0);
  1130.     reservedsym("SHR", KEOP_SHR, 0);
  1131.     reservedsym("XOR", KEOP_XOR, 0);
  1132.     reservedsym("F", CONDITION, 0);
  1133.     reservedsym("C", CONDITION, 0x7);
  1134.     reservedsym("NC", CONDITION, 0xf);
  1135.     reservedsym("Z", CONDITION, 0x6);
  1136.     reservedsym("NZ", CONDITION, 0xe);
  1137.     reservedsym("PL", CONDITION, 0xd);
  1138.     reservedsym("MI", CONDITION, 0x5);
  1139.     reservedsym("OV", CONDITION, 0x4);
  1140.     reservedsym("NOV", CONDITION, 0xc);
  1141.     reservedsym("EQ", CONDITION, 0x6);
  1142.     reservedsym("NE", CONDITION, 0xe);
  1143.     reservedsym("GE", CONDITION, 0x9);
  1144.     reservedsym("LT", CONDITION, 0x1);
  1145.     reservedsym("GT", CONDITION, 0xa);
  1146.     reservedsym("LE", CONDITION, 0x2);
  1147.     reservedsym("UGE", CONDITION, 0xf);
  1148.     reservedsym("ULT", CONDITION, 0x7);
  1149.     reservedsym("UGT", CONDITION, 0xb);
  1150.     reservedsym("ULE", CONDITION, 0x3);
  1151.     reservedsym("R0", REGISTER, REGDEFWRK + 0xe0);
  1152.     reservedsym("R1", REGISTER, REGDEFWRK + 0xe1);
  1153.     reservedsym("R2", REGISTER, REGDEFWRK + 0xe2);
  1154.     reservedsym("R3", REGISTER, REGDEFWRK + 0xe3);
  1155.     reservedsym("R4", REGISTER, REGDEFWRK + 0xe4);
  1156.     reservedsym("R5", REGISTER, REGDEFWRK + 0xe5);
  1157.     reservedsym("R6", REGISTER, REGDEFWRK + 0xe6);
  1158.     reservedsym("R7", REGISTER, REGDEFWRK + 0xe7);
  1159.     reservedsym("R8", REGISTER, REGDEFWRK + 0xe8);
  1160.     reservedsym("R9", REGISTER, REGDEFWRK + 0xe9);
  1161.     reservedsym("R10", REGISTER, REGDEFWRK + 0xea);
  1162.     reservedsym("R11", REGISTER, REGDEFWRK + 0xeb);
  1163.     reservedsym("R12", REGISTER, REGDEFWRK + 0xec);
  1164.     reservedsym("R13", REGISTER, REGDEFWRK + 0xed);
  1165.     reservedsym("R14", REGISTER, REGDEFWRK + 0xee);
  1166.     reservedsym("R15", REGISTER, REGDEFWRK + 0xef);
  1167.     reservedsym("RR0", REGISTER, REGDEFWRK + REGDEFDBL + 0xe0);
  1168.     reservedsym("RR2", REGISTER, REGDEFWRK + REGDEFDBL + 0xe2);
  1169.     reservedsym("RR4", REGISTER, REGDEFWRK + REGDEFDBL + 0xe4);
  1170.     reservedsym("RR6", REGISTER, REGDEFWRK + REGDEFDBL + 0xe6);
  1171.     reservedsym("RR8", REGISTER, REGDEFWRK + REGDEFDBL + 0xe8);
  1172.     reservedsym("RR10", REGISTER, REGDEFWRK + REGDEFDBL + 0xea);
  1173.     reservedsym("RR12", REGISTER, REGDEFWRK + REGDEFDBL + 0xec);
  1174.     reservedsym("RR14", REGISTER, REGDEFWRK + REGDEFDBL + 0xee);
  1175. }
  1176.  
  1177.  
  1178. cpumatch(str)
  1179.     char * str;
  1180. {
  1181.     int msub;
  1182.  
  1183.     static struct
  1184.     {
  1185.         char * mtch;
  1186.         int   cpuv;
  1187.     } matchtab[] =
  1188.     {
  1189.         {"86", CPU8600 },
  1190.         {"z8", CPU8600 },
  1191.         {"Z8", CPU8600 },
  1192.         {"upc", CPU8090 },
  1193.         {"UPC", CPU8090 },
  1194.         {"9", CPU8090 },
  1195.         {"", 0} 
  1196.     };
  1197.  
  1198.     for(msub = 0; matchtab[msub].cpuv != 0; msub++)
  1199.     {
  1200.         if(strcontains(str, matchtab[msub].mtch))
  1201.         {
  1202.             cpuselect = matchtab[msub].cpuv;
  1203.             return TRUE;
  1204.         }
  1205.     }
  1206.  
  1207.     return FALSE;
  1208. }
  1209.  
  1210.  
  1211. strcontains(s1, sm)
  1212.     char * s1, *sm;
  1213. {
  1214.     int l1 = strlen(s1), lm = strlen(sm);
  1215.  
  1216.     for(; l1 >= lm; l1--, s1++)
  1217.     {
  1218.         if(strncmp(s1, sm, lm) == 0)
  1219.         {
  1220.             return TRUE;
  1221.         }
  1222.     }
  1223.     return FALSE;
  1224. }
  1225.  
  1226. /*
  1227.     description    Opcode and Instruction generation tables
  1228.     usage        Unix, framework crossassembler
  1229.     history        September 25, 1987
  1230. */
  1231.  
  1232. #define NUMOPCODE 70
  1233. #define NUMSYNBLK 102
  1234. #define NUMDIFFOP 130
  1235.  
  1236. int gnumopcode = NUMOPCODE;
  1237.  
  1238. int ophashlnk[NUMOPCODE];
  1239.  
  1240. struct opsym optab[NUMOPCODE+1]
  1241.     = {
  1242.     {"invalid", KOC_opcode, 2, 0 },
  1243.     {"ADC", KOC_opcode, 4, 2 },
  1244.     {"ADD", KOC_opcode, 4, 6 },
  1245.     {"AND", KOC_opcode, 4, 10 },
  1246.     {"BYTE", KOC_BDEF, 0, 0 },
  1247.     {"CALL", KOC_opcode, 2, 14 },
  1248.     {"CCF", KOC_opcode, 1, 16 },
  1249.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1250.     {"CHARSET", KOC_CHSET, 0, 0 },
  1251.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1252.     {"CHD", KOC_CHDEF, 0, 0 },
  1253.     {"CLR", KOC_opcode, 2, 17 },
  1254.     {"COM", KOC_opcode, 2, 19 },
  1255.     {"CP", KOC_opcode, 4, 21 },
  1256.     {"CPU", KOC_CPU, 0, 0 },
  1257.     {"DA", KOC_opcode, 2, 25 },
  1258.     {"DB", KOC_BDEF, 0, 0 },
  1259.     {"DEC", KOC_opcode, 2, 27 },
  1260.     {"DECW", KOC_opcode, 2, 29 },
  1261.     {"DI", KOC_opcode, 1, 31 },
  1262.     {"DJNZ", KOC_opcode, 1, 32 },
  1263.     {"DW", KOC_WDEF, 0, 0 },
  1264.     {"EI", KOC_opcode, 1, 33 },
  1265.     {"ELSE", KOC_ELSE, 0, 0 },
  1266.     {"END", KOC_END, 0, 0 },
  1267.     {"ENDI", KOC_ENDI, 0, 0 },
  1268.     {"EQU", KOC_EQU, 0, 0 },
  1269.     {"FCB", KOC_BDEF, 0, 0 },
  1270.     {"FCC", KOC_SDEF, 0, 0 },
  1271.     {"FDB", KOC_WDEF, 0, 0 },
  1272.     {"IF", KOC_IF, 0, 0 },
  1273.     {"INC", KOC_opcode, 2, 34 },
  1274.     {"INCL", KOC_INCLUDE, 0, 0 },
  1275.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1276.     {"INCW", KOC_opcode, 2, 36 },
  1277.     {"IRET", KOC_opcode, 1, 38 },
  1278.     {"JP", KOC_opcode, 3, 39 },
  1279.     {"JR", KOC_opcode, 2, 42 },
  1280.     {"LD", KOC_opcode, 7, 44 },
  1281.     {"LDC", KOC_opcode, 2, 51 },
  1282.     {"LDCI", KOC_opcode, 1, 53 },
  1283.     {"LDE", KOC_opcode, 2, 54 },
  1284.     {"LDEI", KOC_opcode, 1, 56 },
  1285.     {"NOP", KOC_opcode, 1, 57 },
  1286.     {"OR", KOC_opcode, 4, 58 },
  1287.     {"ORG", KOC_ORG, 0, 0 },
  1288.     {"POP", KOC_opcode, 2, 62 },
  1289.     {"PUSH", KOC_opcode, 2, 64 },
  1290.     {"RCF", KOC_opcode, 1, 66 },
  1291.     {"REG", KOC_REG, 0, 0 },
  1292.     {"RESERVE", KOC_RESM, 0, 0 },
  1293.     {"RET", KOC_opcode, 1, 67 },
  1294.     {"RL", KOC_opcode, 2, 68 },
  1295.     {"RLC", KOC_opcode, 2, 70 },
  1296.     {"RMB", KOC_RESM, 0, 0 },
  1297.     {"RR", KOC_opcode, 2, 72 },
  1298.     {"RRC", KOC_opcode, 2, 74 },
  1299.     {"RREG", KOC_RREG, 0, 0 },
  1300.     {"SBC", KOC_opcode, 4, 76 },
  1301.     {"SCF", KOC_opcode, 1, 80 },
  1302.     {"SET", KOC_SET, 0, 0 },
  1303.     {"SRA", KOC_opcode, 2, 81 },
  1304.     {"SRP", KOC_srp, 1, 83 },
  1305.     {"STRING", KOC_SDEF, 0, 0 },
  1306.     {"SUB", KOC_opcode, 4, 84 },
  1307.     {"SWAP", KOC_opcode, 2, 88 },
  1308.     {"TCM", KOC_opcode, 4, 90 },
  1309.     {"TM", KOC_opcode, 4, 94 },
  1310.     {"WORD", KOC_WDEF, 0, 0 },
  1311.     {"XOR", KOC_opcode, 4, 98 },
  1312.     { "", 0, 0, 0 }};
  1313.  
  1314. struct opsynt ostab[NUMSYNBLK+1]
  1315.     = {
  1316. /* invalid 0 */ { 0, 1, 0 },
  1317. /* invalid 1 */ { 0xffff, 1, 1 },
  1318. /* ADC 2 */ { ST_IRIM, 1, 2 },
  1319. /* ADC 3 */ { ST_R2, 2, 3 },
  1320. /* ADC 4 */ { ST_RIMM, 1, 5 },
  1321. /* ADC 5 */ { ST_RIR, 2, 6 },
  1322. /* ADD 6 */ { ST_IRIM, 1, 8 },
  1323. /* ADD 7 */ { ST_R2, 2, 9 },
  1324. /* ADD 8 */ { ST_RIMM, 1, 11 },
  1325. /* ADD 9 */ { ST_RIR, 2, 12 },
  1326. /* AND 10 */ { ST_IRIM, 1, 14 },
  1327. /* AND 11 */ { ST_R2, 2, 15 },
  1328. /* AND 12 */ { ST_RIMM, 1, 17 },
  1329. /* AND 13 */ { ST_RIR, 2, 18 },
  1330. /* CALL 14 */ { ST_EXP, 1, 20 },
  1331. /* CALL 15 */ { ST_IR1, 1, 21 },
  1332. /* CCF 16 */ { ST_INH, 1, 22 },
  1333. /* CLR 17 */ { ST_IR1, 1, 23 },
  1334. /* CLR 18 */ { ST_R1, 1, 24 },
  1335. /* COM 19 */ { ST_IR1, 1, 25 },
  1336. /* COM 20 */ { ST_R1, 1, 26 },
  1337. /* CP 21 */ { ST_IRIM, 1, 27 },
  1338. /* CP 22 */ { ST_R2, 2, 28 },
  1339. /* CP 23 */ { ST_RIMM, 1, 30 },
  1340. /* CP 24 */ { ST_RIR, 2, 31 },
  1341. /* DA 25 */ { ST_IR1, 1, 33 },
  1342. /* DA 26 */ { ST_R1, 1, 34 },
  1343. /* DEC 27 */ { ST_IR1, 1, 35 },
  1344. /* DEC 28 */ { ST_R1, 1, 36 },
  1345. /* DECW 29 */ { ST_IR1, 1, 37 },
  1346. /* DECW 30 */ { ST_R1, 1, 38 },
  1347. /* DI 31 */ { ST_INH, 1, 39 },
  1348. /* DJNZ 32 */ { ST_REXP, 1, 40 },
  1349. /* EI 33 */ { ST_INH, 1, 41 },
  1350. /* INC 34 */ { ST_IR1, 1, 42 },
  1351. /* INC 35 */ { ST_R1, 2, 43 },
  1352. /* INCW 36 */ { ST_IR1, 1, 45 },
  1353. /* INCW 37 */ { ST_R1, 1, 46 },
  1354. /* IRET 38 */ { ST_INH, 1, 47 },
  1355. /* JP 39 */ { ST_CEXP, 1, 48 },
  1356. /* JP 40 */ { ST_EXP, 1, 49 },
  1357. /* JP 41 */ { ST_IR1, 1, 50 },
  1358. /* JR 42 */ { ST_CEXP, 1, 51 },
  1359. /* JR 43 */ { ST_EXP, 1, 52 },
  1360. /* LD 44 */ { ST_IRIM, 1, 53 },
  1361. /* LD 45 */ { ST_IRR, 2, 54 },
  1362. /* LD 46 */ { ST_R2, 3, 56 },
  1363. /* LD 47 */ { ST_RIMM, 2, 59 },
  1364. /* LD 48 */ { ST_RIR, 2, 61 },
  1365. /* LD 49 */ { ST_RX, 1, 63 },
  1366. /* LD 50 */ { ST_XR, 1, 64 },
  1367. /* LDC 51 */ { ST_IRR, 1, 65 },
  1368. /* LDC 52 */ { ST_RIR, 1, 66 },
  1369. /* LDCI 53 */ { ST_IRIR, 2, 67 },
  1370. /* LDE 54 */ { ST_IRR, 1, 69 },
  1371. /* LDE 55 */ { ST_RIR, 1, 70 },
  1372. /* LDEI 56 */ { ST_IRIR, 2, 71 },
  1373. /* NOP 57 */ { ST_INH, 1, 73 },
  1374. /* OR 58 */ { ST_IRIM, 1, 74 },
  1375. /* OR 59 */ { ST_R2, 2, 75 },
  1376. /* OR 60 */ { ST_RIMM, 1, 77 },
  1377. /* OR 61 */ { ST_RIR, 2, 78 },
  1378. /* POP 62 */ { ST_IR1, 1, 80 },
  1379. /* POP 63 */ { ST_R1, 1, 81 },
  1380. /* PUSH 64 */ { ST_IR1, 1, 82 },
  1381. /* PUSH 65 */ { ST_R1, 1, 83 },
  1382. /* RCF 66 */ { ST_INH, 1, 84 },
  1383. /* RET 67 */ { ST_INH, 1, 85 },
  1384. /* RL 68 */ { ST_IR1, 1, 86 },
  1385. /* RL 69 */ { ST_R1, 1, 87 },
  1386. /* RLC 70 */ { ST_IR1, 1, 88 },
  1387. /* RLC 71 */ { ST_R1, 1, 89 },
  1388. /* RR 72 */ { ST_IR1, 1, 90 },
  1389. /* RR 73 */ { ST_R1, 1, 91 },
  1390. /* RRC 74 */ { ST_IR1, 1, 92 },
  1391. /* RRC 75 */ { ST_R1, 1, 93 },
  1392. /* SBC 76 */ { ST_IRIM, 1, 94 },
  1393. /* SBC 77 */ { ST_R2, 2, 95 },
  1394. /* SBC 78 */ { ST_RIMM, 1, 97 },
  1395. /* SBC 79 */ { ST_RIR, 2, 98 },
  1396. /* SCF 80 */ { ST_INH, 1, 100 },
  1397. /* SRA 81 */ { ST_IR1, 1, 101 },
  1398. /* SRA 82 */ { ST_R1, 1, 102 },
  1399. /* SRP 83 */ { ST_IMM, 1, 103 },
  1400. /* SUB 84 */ { ST_IRIM, 1, 104 },
  1401. /* SUB 85 */ { ST_R2, 2, 105 },
  1402. /* SUB 86 */ { ST_RIMM, 1, 107 },
  1403. /* SUB 87 */ { ST_RIR, 2, 108 },
  1404. /* SWAP 88 */ { ST_IR1, 1, 110 },
  1405. /* SWAP 89 */ { ST_R1, 1, 111 },
  1406. /* TCM 90 */ { ST_IRIM, 1, 112 },
  1407. /* TCM 91 */ { ST_R2, 2, 113 },
  1408. /* TCM 92 */ { ST_RIMM, 1, 115 },
  1409. /* TCM 93 */ { ST_RIR, 2, 116 },
  1410. /* TM 94 */ { ST_IRIM, 1, 118 },
  1411. /* TM 95 */ { ST_R2, 2, 119 },
  1412. /* TM 96 */ { ST_RIMM, 1, 121 },
  1413. /* TM 97 */ { ST_RIR, 2, 122 },
  1414. /* XOR 98 */ { ST_IRIM, 1, 124 },
  1415. /* XOR 99 */ { ST_R2, 2, 125 },
  1416. /* XOR 100 */ { ST_RIMM, 1, 127 },
  1417. /* XOR 101 */ { ST_RIR, 2, 128 },
  1418.     { 0, 0, 0 } };
  1419.  
  1420. struct igel igtab[NUMDIFFOP+1]
  1421.     = {
  1422. /* invalid 0 */   { 0 , 0, 
  1423.         "[Xnullentry" },
  1424. /* invalid 1 */   { 0 , 0, 
  1425.         "[Xinvalid opcode" },
  1426. /* ADC 2 */   { 0 , 0, 
  1427.         "17;[1#];[2=];" },
  1428. /* ADC 3 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1429.         "12;[2#4#];" },
  1430. /* ADC 4 */   { 0 , 0, 
  1431.         "14;[3#];[1#];" },
  1432. /* ADC 5 */   { 0 , 0, 
  1433.         "16;[1#];[2=];" },
  1434. /* ADC 6 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1435.         "13;[2#4#];" },
  1436. /* ADC 7 */   { 0 , 0, 
  1437.         "15;[3#];[1#];" },
  1438. /* ADD 8 */   { 0 , 0, 
  1439.         "07;[1#];[2=];" },
  1440. /* ADD 9 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1441.         "02;[2#4#];" },
  1442. /* ADD 10 */   { 0 , 0, 
  1443.         "04;[3#];[1#];" },
  1444. /* ADD 11 */   { 0 , 0, 
  1445.         "06;[1#];[2=];" },
  1446. /* ADD 12 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1447.         "03;[2#4#];" },
  1448. /* ADD 13 */   { 0 , 0, 
  1449.         "05;[3#];[1#];" },
  1450. /* AND 14 */   { 0 , 0, 
  1451.         "57;[1#];[2=];" },
  1452. /* AND 15 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1453.         "52;[2#4#];" },
  1454. /* AND 16 */   { 0 , 0, 
  1455.         "54;[3#];[1#];" },
  1456. /* AND 17 */   { 0 , 0, 
  1457.         "56;[1#];[2=];" },
  1458. /* AND 18 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1459.         "53;[2#4#];" },
  1460. /* AND 19 */   { 0 , 0, 
  1461.         "55;[3#];[1#];" },
  1462. /* CALL 20 */   { 0 , 0, 
  1463.         "d6;[1=]x" },
  1464. /* CALL 21 */   { DSTDBL , DSTDBL, 
  1465.         "d4;[1#];" },
  1466. /* CCF 22 */   { 0 , 0, 
  1467.         "ef;" },
  1468. /* CLR 23 */   { 0 , 0, 
  1469.         "b1;[1#];" },
  1470. /* CLR 24 */   { 0 , 0, 
  1471.         "b0;[1#];" },
  1472. /* COM 25 */   { 0 , 0, 
  1473.         "61;[1#];" },
  1474. /* COM 26 */   { 0 , 0, 
  1475.         "60;[1#];" },
  1476. /* CP 27 */   { 0 , 0, 
  1477.         "a7;[1#];[2=];" },
  1478. /* CP 28 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1479.         "a2;[2#4#];" },
  1480. /* CP 29 */   { 0 , 0, 
  1481.         "a4;[3#];[1#];" },
  1482. /* CP 30 */   { 0 , 0, 
  1483.         "a6;[1#];[2=];" },
  1484. /* CP 31 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1485.         "a3;[2#4#];" },
  1486. /* CP 32 */   { 0 , 0, 
  1487.         "a5;[3#];[1#];" },
  1488. /* DA 33 */   { 0 , 0, 
  1489.         "41;[1#];" },
  1490. /* DA 34 */   { 0 , 0, 
  1491.         "40;[1#];" },
  1492. /* DEC 35 */   { 0 , 0, 
  1493.         "01;[1#];" },
  1494. /* DEC 36 */   { 0 , 0, 
  1495.         "00;[1#];" },
  1496. /* DECW 37 */   { 0 , 0, 
  1497.         "81;[1#];" },
  1498. /* DECW 38 */   { DSTDBL , DSTDBL, 
  1499.         "80;[1#];" },
  1500. /* DI 39 */   { 0 , 0, 
  1501.         "8f;" },
  1502. /* DJNZ 40 */   { DSTWORK , DSTWORK, 
  1503.         "[3#]a;[2=].Q.1+-r" },
  1504. /* EI 41 */   { 0 , 0, 
  1505.         "9f;" },
  1506. /* INC 42 */   { 0 , 0, 
  1507.         "21;[1#];" },
  1508. /* INC 43 */   { DSTWORK , DSTWORK, 
  1509.         "[2#]e;" },
  1510. /* INC 44 */   { 0 , 0, 
  1511.         "20;[1#];" },
  1512. /* INCW 45 */   { 0 , 0, 
  1513.         "a1;[1#];" },
  1514. /* INCW 46 */   { DSTDBL , DSTDBL, 
  1515.         "a0;[1#];" },
  1516. /* IRET 47 */   { 0 , 0, 
  1517.         "bf;" },
  1518. /* JP 48 */   { 0 , 0, 
  1519.         "[1#]d;[2=]x" },
  1520. /* JP 49 */   { 0 , 0, 
  1521.         "8d;[1=]x" },
  1522. /* JP 50 */   { DSTDBL , DSTDBL, 
  1523.         "30;[1#];" },
  1524. /* JR 51 */   { 0 , 0, 
  1525.         "[1#]b;[2=].Q.1+-r" },
  1526. /* JR 52 */   { 0 , 0, 
  1527.         "8b;[1=].Q.1+-r" },
  1528. /* LD 53 */   { 0 , 0, 
  1529.         "e7;[1#];[2=];" },
  1530. /* LD 54 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1531.         "f3;[2#4#];" },
  1532. /* LD 55 */   { 0 , 0, 
  1533.         "f5;[3#];[1#];" },
  1534. /* LD 56 */   { DSTWORK , DSTWORK, 
  1535.         "[2#]8;[3#];" },
  1536. /* LD 57 */   { SRCWORK , SRCWORK, 
  1537.         "[4#]9;[1#];" },
  1538. /* LD 58 */   { 0 , 0, 
  1539.         "e4;[3#];[1#];" },
  1540. /* LD 59 */   { DSTWORK , DSTWORK, 
  1541.         "[3#]c;[2=];" },
  1542. /* LD 60 */   { 0 , 0, 
  1543.         "e6;[1#];[2=];" },
  1544. /* LD 61 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1545.         "e3;[2#4#];" },
  1546. /* LD 62 */   { 0 , 0, 
  1547.         "e5;[3#];[1#];" },
  1548. /* LD 63 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1549.         "c7;[1#3#];[2=];" },
  1550. /* LD 64 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1551.         "d7;[3#2#];[1=];" },
  1552. /* LDC 65 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1553.         "d2;[4#2#];" },
  1554. /* LDC 66 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1555.         "c2;[2#4#];" },
  1556. /* LDCI 67 */   { SRCDBL+DSTDBL+DSTWORK+SRCWORK , SRCDBL+DSTWORK+SRCWORK, 
  1557.         "c3;[2#4#];" },
  1558. /* LDCI 68 */   { SRCDBL+DSTDBL+DSTWORK+SRCWORK , DSTDBL+DSTWORK+SRCWORK, 
  1559.         "d3;[4#2#];" },
  1560. /* LDE 69 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1561.         "92;[4#2#];" },
  1562. /* LDE 70 */   { DSTWORK+SRCWORK , DSTWORK+SRCWORK, 
  1563.         "82;[2#4#];" },
  1564. /* LDEI 71 */   { SRCDBL+DSTDBL+DSTWORK+SRCWORK , SRCDBL+DSTWORK+SRCWORK, 
  1565.         "83;[2#4#];" },
  1566. /* LDEI 72 */   { SRCDBL+DSTDBL+DSTWORK+SRCWORK , DSTDBL+DSTWORK+SRCWORK, 
  1567.         "93;[4#2#];" },
  1568. /* NOP 73 */   { 0 , 0, 
  1569.         "ff;" },
  1570. /* OR 74 */   { 0 , 0, 
  1571.         "47;[1#];[2=];" },
  1572. /* OR 75 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1573.         "42;[2#4#];" },
  1574. /* OR 76 */   { 0 , 0, 
  1575.         "44;[3#];[1#];" },
  1576. /* OR 77 */   { 0 , 0, 
  1577.         "46;[1#];[2=];" },
  1578. /* OR 78 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1579.         "43;[2#4#];" },
  1580. /* OR 79 */   { 0 , 0, 
  1581.         "45;[3#];[1#];" },
  1582. /* POP 80 */   { 0 , 0, 
  1583.         "51;[1#];" },
  1584. /* POP 81 */   { 0 , 0, 
  1585.         "50;[1#];" },
  1586. /* PUSH 82 */   { 0 , 0, 
  1587.         "71;[1#];" },
  1588. /* PUSH 83 */   { 0 , 0, 
  1589.         "70;[1#];" },
  1590. /* RCF 84 */   { 0 , 0, 
  1591.         "cf;" },
  1592. /* RET 85 */   { 0 , 0, 
  1593.         "af;" },
  1594. /* RL 86 */   { 0 , 0, 
  1595.         "91;[1#];" },
  1596. /* RL 87 */   { 0 , 0, 
  1597.         "90;[1#];" },
  1598. /* RLC 88 */   { 0 , 0, 
  1599.         "11;[1#];" },
  1600. /* RLC 89 */   { 0 , 0, 
  1601.         "10;[1#];" },
  1602. /* RR 90 */   { 0 , 0, 
  1603.         "e1;[1#];" },
  1604. /* RR 91 */   { 0 , 0, 
  1605.         "e0;[1#];" },
  1606. /* RRC 92 */   { 0 , 0, 
  1607.         "c1;[1#];" },
  1608. /* RRC 93 */   { 0 , 0, 
  1609.         "c0;[1#];" },
  1610. /* SBC 94 */   { 0 , 0, 
  1611.         "37;[1#];[2=];" },
  1612. /* SBC 95 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1613.         "32;[2#4#];" },
  1614. /* SBC 96 */   { 0 , 0, 
  1615.         "34;[3#];[1#];" },
  1616. /* SBC 97 */   { 0 , 0, 
  1617.         "36;[1#];[2=];" },
  1618. /* SBC 98 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1619.         "33;[2#4#];" },
  1620. /* SBC 99 */   { 0 , 0, 
  1621.         "35;[3#];[1#];" },
  1622. /* SCF 100 */   { 0 , 0, 
  1623.         "df;" },
  1624. /* SRA 101 */   { 0 , 0, 
  1625.         "d1;[1#];" },
  1626. /* SRA 102 */   { 0 , 0, 
  1627.         "d0;[1#];" },
  1628. /* SRP 103 */   { 0 , 0, 
  1629.         "31;[1=];" },
  1630. /* SUB 104 */   { 0 , 0, 
  1631.         "27;[1#];[2=];" },
  1632. /* SUB 105 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1633.         "22;[2#4#];" },
  1634. /* SUB 106 */   { 0 , 0, 
  1635.         "24;[3#];[1#];" },
  1636. /* SUB 107 */   { 0 , 0, 
  1637.         "26;[1#];[2=];" },
  1638. /* SUB 108 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1639.         "23;[2#4#];" },
  1640. /* SUB 109 */   { 0 , 0, 
  1641.         "25;[3#];[1#];" },
  1642. /* SWAP 110 */   { 0 , 0, 
  1643.         "f1;[1#];" },
  1644. /* SWAP 111 */   { 0 , 0, 
  1645.         "f0;[1#];" },
  1646. /* TCM 112 */   { 0 , 0, 
  1647.         "67;[1#];[2=];" },
  1648. /* TCM 113 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1649.         "62;[2#4#];" },
  1650. /* TCM 114 */   { 0 , 0, 
  1651.         "64;[3#];[1#];" },
  1652. /* TCM 115 */   { 0 , 0, 
  1653.         "66;[1#];[2=];" },
  1654. /* TCM 116 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1655.         "63;[2#4#];" },
  1656. /* TCM 117 */   { 0 , 0, 
  1657.         "65;[3#];[1#];" },
  1658. /* TM 118 */   { 0 , 0, 
  1659.         "77;[1#];[2=];" },
  1660. /* TM 119 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1661.         "72;[2#4#];" },
  1662. /* TM 120 */   { 0 , 0, 
  1663.         "74;[3#];[1#];" },
  1664. /* TM 121 */   { 0 , 0, 
  1665.         "76;[1#];[2=];" },
  1666. /* TM 122 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1667.         "73;[2#4#];" },
  1668. /* TM 123 */   { 0 , 0, 
  1669.         "75;[3#];[1#];" },
  1670. /* XOR 124 */   { 0 , 0, 
  1671.         "b7;[1#];[2=];" },
  1672. /* XOR 125 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1673.         "b2;[2#4#];" },
  1674. /* XOR 126 */   { 0 , 0, 
  1675.         "b4;[3#];[1#];" },
  1676. /* XOR 127 */   { 0 , 0, 
  1677.         "b6;[1#];[2=];" },
  1678. /* XOR 128 */   { SRCWORK+DSTWORK , SRCWORK+DSTWORK, 
  1679.         "b3;[2#4#];" },
  1680. /* XOR 129 */   { 0 , 0, 
  1681.         "b5;[3#];[1#];" },
  1682.     { 0,0,""} };
  1683. /* end fraptabdef.c */
  1684.